import { reactive } from 'vue';
import type { DictOption } from '../types';

// 字典存储接口
interface DictStore {
  [code: string]: DictOption[];
}

// sessionStorage 键名
const STORAGE_KEY = 'dict-tag-store';

// 字典数据转换配置接口
export interface DictTransformConfig {
  valueKey?: string; // 值字段名，默认 'value'
  labelKey?: string; // 标签字段名，默认 'label'
}

// 创建响应式的字典存储
const dictStore = reactive<DictStore>({});

// 持久化工具函数
const persistenceUtils = {
  // 保存到 sessionStorage
  save(): void {
    try {
      sessionStorage.setItem(STORAGE_KEY, JSON.stringify(dictStore));
    } catch (error) {
      console.warn('DictManager: 保存到 sessionStorage 失败', error);
    }
  },

  // 从 sessionStorage 加载
  load(): void {
    try {
      const stored = sessionStorage.getItem(STORAGE_KEY);
      if (stored) {
        const parsed = JSON.parse(stored);
        if (typeof parsed === 'object' && parsed !== null) {
          Object.assign(dictStore, parsed);
        }
      }
    } catch (error) {
      console.warn('DictManager: 从 sessionStorage 加载失败', error);
    }
  },

  // 清空 sessionStorage
  clear(): void {
    try {
      sessionStorage.removeItem(STORAGE_KEY);
    } catch (error) {
      console.warn('DictManager: 清空 sessionStorage 失败', error);
    }
  },
};

// 字典管理类
export class DictManager {
  // 初始化时从 sessionStorage 加载数据
  static {
    persistenceUtils.load();
  }
  /**
   * 转换字典数据为标准格式
   * @param data 原始数据
   * @param config 转换配置
   * @returns 标准格式的字典数据
   */
  private static transformDictData(
    data: any[],
    config: DictTransformConfig = {}
  ): DictOption[] {
    if (!Array.isArray(data)) return [];

    const { valueKey = 'value', labelKey = 'label' } = config;

    return data.map((item) => {
      if (typeof item !== 'object' || item === null) {
        return { value: '', label: '' };
      }

      return {
        value: item[valueKey] ?? item.value ?? '',
        label:
          item[labelKey] ??
          item.label ??
          item.text ??
          item.name ??
          item.title ??
          '',
      };
    });
  }
  /**
   * 设置单个字典数据
   * @param code 字典代码
   * @param data 字典数据
   * @param config 数据转换配置
   */
  static setDict(
    code: string,
    data: any[],
    config?: DictTransformConfig
  ): void {
    if (!code) {
      console.warn('DictManager.setDict: 字典代码不能为空');
      return;
    }

    try {
      if (Array.isArray(data)) {
        // 转换数据为标准格式
        const transformedData = this.transformDictData(data, config);
        dictStore[code] = transformedData;
        // 自动保存到 sessionStorage
        persistenceUtils.save();
      } else {
        console.warn(
          `DictManager.setDict: 字典数据必须是数组类型，code: ${code}`
        );
        dictStore[code] = [];
        // 即使数据无效也要保存到 sessionStorage
        persistenceUtils.save();
      }
    } catch (error) {
      console.error(
        `DictManager.setDict: 设置字典数据时发生错误，code: ${code}`,
        error
      );
      dictStore[code] = [];
      // 发生错误时也要保存到 sessionStorage
      persistenceUtils.save();
    }
  }

  /**
   * 批量设置字典数据
   * @param dicts 字典数据对象，key为字典代码，value为字典数据
   * @param config 数据转换配置
   */
  static setDicts(
    dicts: Record<string, any[]>,
    config?: DictTransformConfig
  ): void {
    if (!dicts || typeof dicts !== 'object') {
      console.warn('DictManager.setDicts: 字典数据必须是对象类型');
      return;
    }

    Object.keys(dicts).forEach((code) => {
      const data = dicts[code];
      if (Array.isArray(data)) {
        // 转换数据为标准格式
        const transformedData = this.transformDictData(data, config);
        dictStore[code] = transformedData;
      } else if (data) {
        console.warn(
          `DictManager.setDicts: 字典数据必须是数组类型，code: ${code}`
        );
        dictStore[code] = [];
      }
    });

    // 批量设置完成后保存到 sessionStorage
    persistenceUtils.save();
  }

  /**
   * 获取字典数据
   * @param code 字典代码
   * @returns 字典数据数组
   */
  static getDict(code: string): DictOption[] {
    if (!code || !this.hasDict(code)) return [];
    const data = dictStore[code];
    return Array.isArray(data) ? data : [];
  }

  /**
   * 获取所有字典数据
   * @returns 所有字典数据
   */
  static getAllDicts(): DictStore {
    return { ...dictStore };
  }

  /**
   * 清空指定字典
   * @param code 字典代码
   */
  static clearDict(code: string): void {
    if (code && this.hasDict(code)) {
      delete dictStore[code];
      // 保存到 sessionStorage
      persistenceUtils.save();
    }
  }

  /**
   * 清空所有字典
   */
  static clearAllDicts(): void {
    Object.keys(dictStore).forEach((code) => {
      delete dictStore[code];
    });
    // 清空 sessionStorage
    persistenceUtils.clear();
  }

  /**
   * 检查字典是否存在
   * @param code 字典代码
   * @returns 是否存在
   */
  static hasDict(code: string): boolean {
    return code in dictStore;
  }

  /**
   * 获取字典数量
   * @returns 字典数量
   */
  static getDictCount(): number {
    return Object.keys(dictStore).length;
  }

  /**
   * 设置不同格式的字典数据（便捷方法）
   * @param code 字典代码
   * @param data 原始数据
   * @param valueKey 值字段名
   * @param labelKey 标签字段名
   */
  static setDictWithKeys(
    code: string,
    data: any[],
    valueKey: string = 'value',
    labelKey: string = 'label'
  ): void {
    this.setDict(code, data, { valueKey, labelKey });
  }

  /**
   * 批量设置不同格式的字典数据（便捷方法）
   * @param dicts 字典数据对象
   * @param valueKey 值字段名
   * @param labelKey 标签字段名
   */
  static setDictsWithKeys(
    dicts: Record<string, any[]>,
    valueKey: string = 'value',
    labelKey: string = 'label'
  ): void {
    this.setDicts(dicts, { valueKey, labelKey });
  }

  /**
   * 手动保存到 sessionStorage
   */
  static saveToStorage(): void {
    persistenceUtils.save();
  }

  /**
   * 手动从 sessionStorage 加载
   */
  static loadFromStorage(): void {
    persistenceUtils.load();
  }

  /**
   * 清空 sessionStorage
   */
  static clearStorage(): void {
    persistenceUtils.clear();
  }
}

// 导出字典存储实例（用于调试）
export { dictStore };
